package view.backing.Transformaciones;

import chemtools_logica.Beans.AlmacenBean;
import chemtools_logica.Beans.DetalleformulaBean;
import chemtools_logica.Beans.EventoxinsumoBean;
import chemtools_logica.Beans.EventoxproductoBean;
import chemtools_logica.Beans.FormulaBean;
import chemtools_logica.Beans.InsumoBean;
import chemtools_logica.Beans.LaboratorioBean;
import chemtools_logica.Beans.OrdenproduccionBean;
import chemtools_logica.Beans.OrdenproduccionxTipoproduccionBean;
import chemtools_logica.Beans.ProductoBean;
import chemtools_logica.Beans.TipoinsumoBean;
import chemtools_logica.Beans.UsuarioBean;

import chemtools_logica.Entidades.Formula;
import chemtools_logica.Entidades.Ordenproduccion;

import chemtools_logica.LN.IR.LN_SFAlmacenRemote;
import chemtools_logica.LN.IR.LN_SFContenedoresRemote;
import chemtools_logica.LN.IR.LN_SFEmpresaRemote;
import chemtools_logica.LN.IR.LN_SFInsumoRemote;
import chemtools_logica.LN.IR.LN_SFMedidaRemote;
import chemtools_logica.LN.IR.LN_SFOrdenproduccionRemote;
import chemtools_logica.LN.IR.LN_SFProductoRemote;
import chemtools_logica.LN.IR.LN_SFTipoinsumoRemote;

import chemtools_logica.LN.IR.LN_SFTransformacionesRemote;

import java.math.BigDecimal;

import java.util.ArrayList;
import java.util.Date;
import java.util.Hashtable;

import java.util.List;

import javax.annotation.PostConstruct;

import javax.faces.context.FacesContext;

import javax.faces.event.ActionEvent;

import javax.faces.event.ValueChangeEvent;

import javax.faces.model.SelectItem;

import javax.naming.Context;

import javax.naming.InitialContext;
import javax.naming.NamingException;

import javax.servlet.http.HttpSession;

import oracle.adf.view.rich.component.rich.RichForm;
import oracle.adf.view.rich.component.rich.RichPopup;
import oracle.adf.view.rich.component.rich.data.RichTable;
import oracle.adf.view.rich.component.rich.input.RichInputDate;
import oracle.adf.view.rich.component.rich.input.RichInputText;
import oracle.adf.view.rich.component.rich.input.RichSelectBooleanCheckbox;
import oracle.adf.view.rich.component.rich.input.RichSelectOneChoice;
import oracle.adf.view.rich.component.rich.nav.RichButton;

import oracle.adf.view.rich.component.rich.nav.RichCommandButton;

import oracle.adf.view.rich.render.ClientEvent;

import org.apache.myfaces.trinidad.event.SelectionEvent;

import view.backing.Utils.Utils;

public class Frm_transformaciones {
    private bSessionScopeBeanTransformaciones sessionScopeBeanTransformaciones = new bSessionScopeBeanTransformaciones();
    private RichInputText nombreLabInputBusqueda;
    private RichInputDate fecIniInputDateBusqueda;
    private RichInputDate fecFinInputDateBusqueda;
    private RichSelectOneChoice estadoSelectOneChoiceBusqueda;
    private RichForm formTransformaciones;
    private RichTable tableOrdenesResultado;
    private LN_SFTransformacionesRemote lN_SFTransformacionesRemote;
    private LN_SFInsumoRemote lN_SFInsumoRemote;
    private LN_SFAlmacenRemote lN_SFAlmacenRemote;
    private LN_SFProductoRemote lN_SFProductoRemote;
    private RichPopup popOrdenSelec;
    private RichTable tpOrd;
    private RichPopup popBusF;
    private RichTable tform;
    private RichPopup popDetalle;
    private RichTable tdetalle;
    private RichPopup popInsumo;
    private RichTable ttipoIns;
    private RichInputText referencia;
    private RichPopup popInsumoVerdadero;
    private RichTable tinsV;
    private RichSelectBooleanCheckbox selBool1;
    private RichPopup popAlmacen;
    private RichSelectOneChoice sooAlm;


    public Frm_transformaciones(){
    }
    
    @PostConstruct
    public void methodInvokeOncedOnPageLoad() {
        try {
            final Context context = getInitialContext();
            lN_SFTransformacionesRemote = (LN_SFTransformacionesRemote) context.lookup("map-LN_SFTransformaciones#chemtools_logica.LN.IR.LN_SFTransformacionesRemote");
            lN_SFInsumoRemote = (LN_SFInsumoRemote) context.lookup("map-LN_SFInsumo#chemtools_logica.LN.IR.LN_SFInsumoRemote");
            lN_SFAlmacenRemote = (LN_SFAlmacenRemote) context.lookup("map-LN_SFAlmacen#chemtools_logica.LN.IR.LN_SFAlmacenRemote");
            lN_SFProductoRemote = (LN_SFProductoRemote) context.lookup("map-LN_SFProducto#chemtools_logica.LN.IR.LN_SFProductoRemote");
        } catch (Exception e){
        
        }
        HttpSession sesion = (HttpSession) FacesContext.getCurrentInstance().getExternalContext().getSession(true);
        UsuarioBean usuario = (UsuarioBean) sesion.getAttribute("usuario");
        sessionScopeBeanTransformaciones.setUsuario(usuario);
    }
    
    public void busquedaOrdenesProduccion(ActionEvent event){
        OrdenproduccionBean bean = new OrdenproduccionBean();
        LaboratorioBean lab = new LaboratorioBean();
        lab.setNombre(sessionScopeBeanTransformaciones.getFiltro().getNombreLab());
        bean.setLaboratorio(lab);
        bean.setEstado(sessionScopeBeanTransformaciones.getFiltro().getEstado());
        bean.setFechaRegistroDesde(sessionScopeBeanTransformaciones.getFiltro().getFecIni());
        bean.setFechaRegistroHasta(sessionScopeBeanTransformaciones.getFiltro().getFecFin());
        sessionScopeBeanTransformaciones.getOrdenesMostradas().clear();
        sessionScopeBeanTransformaciones.getOrdenesMostradas().addAll(lN_SFTransformacionesRemote.getOrdenProduccionFiltrado(bean));
        Utils.addTarget(getTableOrdenesResultado());
    }
    
    public void busquedaFormulasComp(ActionEvent event){
        sessionScopeBeanTransformaciones.getFormulasCompatibles().clear();
        sessionScopeBeanTransformaciones.setFormulasCompatibles(lN_SFTransformacionesRemote.busquedaFormulasCompatibles(sessionScopeBeanTransformaciones.getIdProdSeleccionado()));
        Utils.showPopUp(getPopBusF(),referencia);
    }
    
    public void busquedaDetalle(ActionEvent event){
        sessionScopeBeanTransformaciones.getFormulasCompatibles().clear();
        sessionScopeBeanTransformaciones.setFormulasCompatibles(lN_SFTransformacionesRemote.busquedaFormulasCompatibles(sessionScopeBeanTransformaciones.getIdProdSeleccionado()));
        FormulaBean formula = sessionScopeBeanTransformaciones.getFormulasCompatibles().get(0);
        sessionScopeBeanTransformaciones.setNombreForm(formula.getDescripcion());
        sessionScopeBeanTransformaciones.setDetalleList(lN_SFTransformacionesRemote.busquedaDetalle(Integer.parseInt(formula.getIdFormula()+"")));
        DetalleformulaBean aux = new DetalleformulaBean();
        aux = sessionScopeBeanTransformaciones.getDetalleList().get(0);
        sessionScopeBeanTransformaciones.setMedida(aux.getTipoproducto().getMedida().getDescripcion());
        sessionScopeBeanTransformaciones.setCantidad(aux.getCantidad_Producto());
        sessionScopeBeanTransformaciones.setNombre(aux.getTipoproducto().getDescripcion());
        Utils.showPopUp(getPopDetalle(),referencia);
    }
    
    public void seleccionFormula(ActionEvent event){
        FormulaBean formulaSelected = (FormulaBean) event.getComponent().getAttributes().get("formSelec");
        for(OrdenproduccionxTipoproduccionBean bean: sessionScopeBeanTransformaciones.getProductos()){
            if(sessionScopeBeanTransformaciones.getIdProdSeleccionado() == bean.getTipoproducto().getIdTipoProducto()){
                bean.setFormula(formulaSelected);
                bean.setNombreFormula(formulaSelected.getDescripcion());
                bean.setFormulaSelec(true);
                break;
            }
        }
        Utils.addTarget(tpOrd);
        popBusF.hide();
    }
    
    public void closeInsumos(ActionEvent actionEvent) {
        popInsumo.hide();
    }
    
    public void closeAlmacen(ActionEvent actionEvent) {
        sessionScopeBeanTransformaciones.setCodigoProd("");
        sessionScopeBeanTransformaciones.setIdAlmacen(0);
        sessionScopeBeanTransformaciones.setCalidadProd(0);
        sessionScopeBeanTransformaciones.setComentarioProd("");
        sessionScopeBeanTransformaciones.setFechaCaducProd(null);
        popAlmacen.hide();
    }
    
    public void selectOrdenProduccion(SelectionEvent se){
        RichTable t = (RichTable)se.getSource();
        OrdenproduccionBean beanOrden = (OrdenproduccionBean) t.getSelectedRowData();
        beanOrden.setProductos(lN_SFTransformacionesRemote.getProductosOrden(beanOrden));  
        sessionScopeBeanTransformaciones.setOrdenSelected(beanOrden);
        sessionScopeBeanTransformaciones.setProductos(beanOrden.getProductos());
        sessionScopeBeanTransformaciones.getFormulasCompatibles().clear();
        for(OrdenproduccionxTipoproduccionBean bean: sessionScopeBeanTransformaciones.getProductos()){
            sessionScopeBeanTransformaciones.setFormulasCompatibles(lN_SFTransformacionesRemote.busquedaFormulasCompatibles(bean.getTipoproducto().getIdTipoProducto()));
            FormulaBean formula = sessionScopeBeanTransformaciones.getFormulasCompatibles().get(0);
            bean.setFormula(formula);
            bean.setNombreFormula(formula.getDescripcion());
            bean.setFormulaSelec(true);
        }
        
        Utils.showPopUp(getPopOrdenSelec(),referencia);
        
    }
    
    public void selectProducto(SelectionEvent se) {
        RichTable t = (RichTable)se.getSource();
        OrdenproduccionxTipoproduccionBean bean = (OrdenproduccionxTipoproduccionBean) t.getSelectedRowData();
        sessionScopeBeanTransformaciones.setProductoNotSelected(false);
        //Utils.addTarget(getBtnFijarForm());
        sessionScopeBeanTransformaciones.setIdProdSeleccionado(bean.getTipoproducto().getIdTipoProducto());
    }
    
    public void mostrarTipoInsumos(ActionEvent event) {
        sessionScopeBeanTransformaciones.getInsumosExistentes().clear();
        OrdenproduccionxTipoproduccionBean ordTpBean = (OrdenproduccionxTipoproduccionBean) event.getComponent().getAttributes().get("prodSelect");
        if(ordTpBean.getConformidad() == ordTpBean.getCantidad()){
            Utils.showMessage("Ya se hizo la cantidad pedida para esta orden para este producto", null, 1);
            return;
        }
        sessionScopeBeanTransformaciones.setProdSelected(ordTpBean);
        sessionScopeBeanTransformaciones.setInsumoMostrados(lN_SFTransformacionesRemote.busquedaItemTipoFromDetalle(ordTpBean.getFormula().getIdFormula(), ordTpBean.getTipoproducto().getIdTipoProducto()));
        Utils.showPopUp(popInsumo,referencia);
    }
    
    private boolean isLookedForInsumo(TipoinsumoBean tInsBean){
        for(int idIns : sessionScopeBeanTransformaciones.getInsumosBuscados()){
            if(idIns == tInsBean.getIdTipoInsumo()){
                return false;
            }
        }
        sessionScopeBeanTransformaciones.getInsumosBuscados().add(tInsBean.getIdTipoInsumo());
        return true;
    }
    
    private void llenarInsumosDisp(int idTipoIns){
        sessionScopeBeanTransformaciones.setInsumosDisponibles(new ArrayList<InsumoBean>());
        for(InsumoBean bean : sessionScopeBeanTransformaciones.getInsumosExistentes()){
            if(bean.getIdtipoInsumo() == idTipoIns){
                //if(bean.isUtilizable()){
                    sessionScopeBeanTransformaciones.getInsumosDisponibles().add(bean);
                //}
            }
        }
    }
    
    public void calcularProgreso(ValueChangeEvent event) {
        InsumoBean bean = (InsumoBean) event.getComponent().getAttributes().get("Usado");
        boolean satisfecho = false;
        for(DetalleformulaBean detalleForm: sessionScopeBeanTransformaciones.getInsumoMostrados()){
            if(detalleForm.getTipoinsumo().getIdTipoInsumo() == bean.getIdtipoInsumo()){
                if(detalleForm.isSatisfecho()){
                    satisfecho = true;
                }
            }
        }
        if(satisfecho){
            if(event.getNewValue().toString().equalsIgnoreCase("true")){
                bean.setSeleccionado(false);
                for(InsumoBean ins: sessionScopeBeanTransformaciones.getInsumosDisponibles()){
                    if(ins.getIdInsumo() == bean.getIdInsumo()){
                        ins.setSeleccionado(false);
                        Utils.showMessage("Ya Completo los Insumos Necesarios de este tipo para cumplir la produccion de este producto", null, 1);
                        selBool1.setDisabled(true);
                        break;
                    }
                }
                Utils.addTarget(tinsV);
                Utils.addTarget(selBool1);
                return;
            }
        }
        int cantidad = 0;
        //System.out.println("Entro al calcularProgreso evento");
        for(InsumoBean ins: sessionScopeBeanTransformaciones.getInsumosDisponibles()){
            if(ins.getIdInsumo() == bean.getIdInsumo()){
                ins.setSeleccionado(!ins.isSeleccionado());
            }
            if(ins.isSeleccionado()){
                cantidad += ins.getContenido().doubleValue();
            }
        }
        int demanda = 0;
        for(DetalleformulaBean detalleForm: sessionScopeBeanTransformaciones.getInsumoMostrados()){
            if(detalleForm.getTipoinsumo().getIdTipoInsumo() == bean.getIdtipoInsumo()){
                demanda = detalleForm.getCantidad_Insumo()*(sessionScopeBeanTransformaciones.getProdSelected().getCantidad()-sessionScopeBeanTransformaciones.getProdSelected().getConformidad());
            }
        }
        boolean aux;
        if(cantidad >= demanda){
            aux = true;
            cantidad = demanda;
        } else {
            aux = false;
        }
        for(DetalleformulaBean detalleForm: sessionScopeBeanTransformaciones.getInsumoMostrados()){
            if(detalleForm.getTipoinsumo().getIdTipoInsumo() == bean.getIdtipoInsumo()){
                detalleForm.setSatisfecho(aux);
                detalleForm.setCantidadCumplida(cantidad/detalleForm.getCantidad_Insumo());
                if(aux){
                    //detalleForm.setInsFijados(true);
                }
            }
        }
        if(aux){
            selBool1.setDisabled(true);
            Utils.showMessage("Ya Completo los Insumos Necesarios de este tipo para cumplir la produccion de este producto", null, 2);
        }
        Utils.addTarget(tinsV);
        Utils.addTarget(ttipoIns);
    }
    
    public void setInsumos(ActionEvent actionEvent) {
        for(DetalleformulaBean detalleForm: sessionScopeBeanTransformaciones.getInsumoMostrados()){
            if(detalleForm.getTipoinsumo().getIdTipoInsumo() == sessionScopeBeanTransformaciones.getIdTipoInsumo()){
                if(detalleForm.getCantidadCumplida() == 0){
                    Utils.showMessage("Al menos debe poder producirse un producto para poder fijar estos insumos", null, 1);
                    return;
                }
                detalleForm.setInsFijados(true);
                break;
            }
        }
        for(OrdenproduccionxTipoproduccionBean bean : sessionScopeBeanTransformaciones.getProductos()){
            if(bean.getTipoproducto().getIdTipoProducto()==sessionScopeBeanTransformaciones.getProdSelected().getTipoproducto().getIdTipoProducto()){
                for(InsumoBean ins: sessionScopeBeanTransformaciones.getInsumosDisponibles()){
                    if(ins.isSeleccionado()){
                        System.out.println("Estoy Fijando: "+ins.getIdInsumo());
                        bean.getInsumosAUsar().add(ins);
                        ins.setUtilizable(false);
                    }
                    for(InsumoBean insMos: sessionScopeBeanTransformaciones.getInsumosExistentes()){
                        if(insMos.getIdInsumo().equalsIgnoreCase(ins.getIdInsumo())){
                            insMos.setUtilizable(false);
                            break;
                        }
                    }
                }
            }
        }
        Utils.addTarget(ttipoIns);
        selBool1.setDisabled(false);
        popInsumoVerdadero.hide();
    }
    
    public void mostrarInsumosVerdaderos(ActionEvent event) {
        InsumoBean ins = new InsumoBean();
        TipoinsumoBean tIns = (TipoinsumoBean) event.getComponent().getAttributes().get("tipoIns");
        ins.setTipoinsumo1(tIns);
        sessionScopeBeanTransformaciones.getInsumosExistentes().clear();
        //if(isLookedForInsumo(tIns)){
            List<InsumoBean> insumoList = lN_SFInsumoRemote.getBusquedaInsumosCompletoTransformaciones(ins);
            sessionScopeBeanTransformaciones.getInsumosExistentes().addAll(insumoList);
        //}
        sessionScopeBeanTransformaciones.setIdTipoInsumo(tIns.getIdTipoInsumo());
        llenarInsumosDisp(tIns.getIdTipoInsumo());
        Utils.showPopUp(popInsumoVerdadero,referencia);
        if(selBool1 != null){
            selBool1.setDisabled(false);    
        }
        //selBool1.setDisabled(false);
    }
    
    public void producir(ActionEvent actionEvent) {
        int idUsuario = sessionScopeBeanTransformaciones.getUsuario().getIdUsuario();
        agregarNuevoProductoPropio();
        boolean finalizado = true;
        for(OrdenproduccionxTipoproduccionBean bean : sessionScopeBeanTransformaciones.getProductos()){
            if(bean.getTipoproducto().getIdTipoProducto() == sessionScopeBeanTransformaciones.getIdProdSeleccionado()){
                int idFormula = bean.getFormula().getIdFormula();
                String idProducto = sessionScopeBeanTransformaciones.getCodigoProd();
                int idOrden = sessionScopeBeanTransformaciones.getOrdenSelected().getIdOrdenProduccion();
                int idTipoInsumo = 0;
                double cantNec = 0;
                //System.out.println("GUARDA:"+bean.getInsumosAUsar().size());
                for(InsumoBean ins: bean.getInsumosAUsar()){
                    if(ins.getIdtipoInsumo() != idTipoInsumo){
                        for(DetalleformulaBean aux : sessionScopeBeanTransformaciones.getInsumoMostrados()){
                            if(aux.getTipoinsumo().getIdTipoInsumo() == ins.getIdtipoInsumo()){
                                cantNec = aux.getCantidad_Insumo()*aux.getCantidad_Producto()*(sessionScopeBeanTransformaciones.getContenidoProd());
                            }
                        }
                        idTipoInsumo = ins.getIdtipoInsumo();
                    }
                    int cantUsada;
                    if(ins.getContenido().doubleValue() > cantNec){
                        ins.setContenido(new BigDecimal(ins.getContenido().doubleValue() - cantNec));
                        cantUsada = (int) cantNec;
                        ins.setEstado(2);
                    } else {
                        ins.setContenido(new BigDecimal(0));
                        ins.setEstado(3);
                        cantUsada = ins.getContenido().intValue();
                        cantNec = cantNec - ins.getContenido().doubleValue();
                    }
                    int idEvento = 9;
                    
                    editarInsumo(ins, idEvento,cantUsada);
                    
                    lN_SFTransformacionesRemote.transformar(ins.getIdInsumo(), 
                                                            idProducto, 
                                                            idUsuario, 
                                                            idFormula, 
                                                            idOrden, 
                                                            sessionScopeBeanTransformaciones.getContenidoProd()+"");
                    
                }
                int conf = (int)sessionScopeBeanTransformaciones.getContenidoProd();
                bean.setConformidad(conf+bean.getConformidad());
                
                lN_SFTransformacionesRemote.updateConformidad(bean);
            }
            if(bean.getConformidad() < bean.getCantidad()){
                finalizado = false;
            }
        }
        String mensaje = "";
        mensaje +=  "Se ha producido el producto "+sessionScopeBeanTransformaciones.getProdSelected().getTipoproducto().getDescripcion()+
                    "en "+sessionScopeBeanTransformaciones.getContenidoProd();
        if(finalizado){
            sessionScopeBeanTransformaciones.getOrdenSelected().setEstado(4);
            mensaje+="\n Ya ha concluido con esta orden de produccion";
        } else {
            sessionScopeBeanTransformaciones.getOrdenSelected().setEstado(2);
        }
        lN_SFTransformacionesRemote.cambiaEstadoOrden(sessionScopeBeanTransformaciones.getOrdenSelected());
        popInsumo.hide();
        popInsumoVerdadero.hide();
        popAlmacen.hide();
        Utils.addTarget(tpOrd);
        Utils.showMessage(mensaje, null, 2);
        sessionScopeBeanTransformaciones.getInsumoMostrados().clear();
        sessionScopeBeanTransformaciones.getInsumosBuscados().clear();
        sessionScopeBeanTransformaciones.getInsumosDisponibles().clear();
        sessionScopeBeanTransformaciones.getInsumosExistentes().clear();
        busquedaOrdenesProduccion(null);
        Utils.addTarget(tableOrdenesResultado);
    }
    
    public void editarInsumo(InsumoBean ins, int idEvento, int cantUsada){
        InsumoBean beanInsumo = ins;            
        EventoxinsumoBean eventoxinsumo = new EventoxinsumoBean();
        eventoxinsumo.setInsumo(beanInsumo);
        eventoxinsumo.setFecha_Evento(new Date());
        eventoxinsumo.setIdEvento(idEvento);
        eventoxinsumo.setIdAlmacen(beanInsumo.getIdAlmacen());
        eventoxinsumo.setContenido(new BigDecimal(cantUsada));
        eventoxinsumo.setIdUsuario(sessionScopeBeanTransformaciones.getUsuario().getIdUsuario());
        eventoxinsumo.setIdProducto(sessionScopeBeanTransformaciones.getCodigoProd());
        lN_SFTransformacionesRemote.updateInsumoTrans(ins,eventoxinsumo);
    }
    
    public void agregarNuevoProductoPropio(){
        String comentario = sessionScopeBeanTransformaciones.getComentarioProd();
        String codigo = sessionScopeBeanTransformaciones.getCodigoProd();
        int calidad = sessionScopeBeanTransformaciones.getCalidadProd();
        int tProd = sessionScopeBeanTransformaciones.getIdProdSeleccionado();
        int empresa = 1000000;
        Date fCaducacion = sessionScopeBeanTransformaciones.getFechaCaducProd();
        double contenido = sessionScopeBeanTransformaciones.getContenidoProd();
        
        int almacen = sessionScopeBeanTransformaciones.getIdAlmacen(); 
        int usuario = sessionScopeBeanTransformaciones.getUsuario().getIdUsuario();
        
        ProductoBean beanProducto = new ProductoBean();
        EventoxproductoBean eventoxproducto = new EventoxproductoBean();
        
        beanProducto.setIdProducto(codigo);
        beanProducto.setCalidad(calidad);
        beanProducto.setComentario(comentario);
        beanProducto.setEstado(1);
        beanProducto.setIdEmpresa(empresa);
        beanProducto.setIdtipoProducto(tProd);
        beanProducto.setImagen("");
        beanProducto.setTiempo_Caducacion(fCaducacion);
        
        BigDecimal cont = new BigDecimal(contenido);
        
        beanProducto.setContenido(cont);
        
        eventoxproducto.setProducto(beanProducto);
        eventoxproducto.setIdEvento(5);
        eventoxproducto.setIdAlmacen(almacen);
        eventoxproducto.setIdUsuario(usuario);
        eventoxproducto.setFecha_Evento(new Date());
        eventoxproducto.setContenido(cont);
        
        lN_SFProductoRemote.insertarProducto(eventoxproducto);
    }
    
    public void verificar(ActionEvent actionEvent) {
        sessionScopeBeanTransformaciones.setCodigoProd("");
        sessionScopeBeanTransformaciones.setIdAlmacen(0);
        sessionScopeBeanTransformaciones.setCalidadProd(0);
        sessionScopeBeanTransformaciones.setComentarioProd("");
        sessionScopeBeanTransformaciones.setFechaCaducProd(null);
        double cantPosProducir = Double.MAX_VALUE;
        for(DetalleformulaBean detalleForm: sessionScopeBeanTransformaciones.getInsumoMostrados()){
            if(detalleForm.getCantidadCumplida()== 0){
                Utils.showMessage("No se puede producir pues falta fijar el insumo: "+detalleForm.getTipoinsumo().getDescripcion(), null, 1);
                return;
            }
            if(cantPosProducir > detalleForm.getCantidadCumplida()){
                cantPosProducir = detalleForm.getCantidadCumplida();
            }
        }
        for(OrdenproduccionxTipoproduccionBean bean : sessionScopeBeanTransformaciones.getProductos()){
            if(bean.getTipoproducto().getIdTipoProducto() == sessionScopeBeanTransformaciones.getIdProdSeleccionado()){
                double necesidad = bean.getCantidad() - bean.getConformidad();        
                if(cantPosProducir > necesidad){
                    cantPosProducir = necesidad;
                }
            }
        }
        sessionScopeBeanTransformaciones.setContenidoProd(cantPosProducir);
        List<AlmacenBean> aux = lN_SFAlmacenRemote.getAllAlmacenes1();
        sessionScopeBeanTransformaciones.setAlmacenes(new ArrayList<SelectItem>());
        for(AlmacenBean bean : aux){
            SelectItem item = new SelectItem();
            item.setLabel(bean.getNombre());
            item.setValue(bean.getIdAlmacen());
            sessionScopeBeanTransformaciones.getAlmacenes().add(item);
        }
        Utils.showPopUp(popAlmacen, referencia);
    }
    
    public void close(ActionEvent actionEvent) {
        popDetalle.hide();
    }
    
    public void limpiar(ActionEvent actionEvent) {
        sessionScopeBeanTransformaciones.setFiltro(new TransformacionesFiltro());
        sessionScopeBeanTransformaciones.getOrdenesMostradas().clear();
        Utils.addTarget(tableOrdenesResultado);
        Utils.addTarget(estadoSelectOneChoiceBusqueda);
        Utils.addTarget(fecFinInputDateBusqueda);
        Utils.addTarget(fecIniInputDateBusqueda);
        Utils.addTarget(nombreLabInputBusqueda);
    }
    
    public void ordenSelectedClose(ActionEvent actionEvent) {
        popOrdenSelec.hide();
        Utils.clearRowSelection(tableOrdenesResultado);
        Utils.addTarget(tableOrdenesResultado);
        sessionScopeBeanTransformaciones.setOrdenSelected(new OrdenproduccionBean());
    }
    
    public void deshacerSeleccion(ActionEvent actionEvent) {
        selBool1 = new RichSelectBooleanCheckbox();
        Utils.addTarget(selBool1);
        for(DetalleformulaBean detalleForm: sessionScopeBeanTransformaciones.getInsumoMostrados()){
            if(detalleForm.getTipoinsumo().getIdTipoInsumo() == sessionScopeBeanTransformaciones.getIdTipoInsumo()){
                detalleForm.setSatisfecho(false);
                detalleForm.setCantidadCumplida(0);
            }
        }
        Utils.addTarget(ttipoIns);
        selBool1.setDisabled(false);
        Utils.addTarget(tinsV);
        popInsumoVerdadero.hide();
    }
    
    private static Context getInitialContext() throws NamingException {
        Hashtable env = new Hashtable();
        // WebLogic Server 10.x/12.x connection details
        env.put(Context.INITIAL_CONTEXT_FACTORY, "weblogic.jndi.WLInitialContextFactory");
        env.put(Context.PROVIDER_URL, "t3://127.0.0.1:7101");
        return new InitialContext(env);
    }
    
    public void setNombreLabInputBusqueda(RichInputText nombreLabInputBusqueda) {
        this.nombreLabInputBusqueda = nombreLabInputBusqueda;
    }

    public RichInputText getNombreLabInputBusqueda() {
        return nombreLabInputBusqueda;
    }
    
    public void setSessionScopeBeanTransformaciones(bSessionScopeBeanTransformaciones sessionScopeBeanTransformaciones) {
        this.sessionScopeBeanTransformaciones = sessionScopeBeanTransformaciones;
    }

    public bSessionScopeBeanTransformaciones getSessionScopeBeanTransformaciones() {
        return sessionScopeBeanTransformaciones;
    }

    public void setFecIniInputDateBusqueda(RichInputDate fecIniInputDateBusqueda) {
        this.fecIniInputDateBusqueda = fecIniInputDateBusqueda;
    }

    public RichInputDate getFecIniInputDateBusqueda() {
        return fecIniInputDateBusqueda;
    }

    public void setFecFinInputDateBusqueda(RichInputDate fecFinInputDateBusqueda) {
        this.fecFinInputDateBusqueda = fecFinInputDateBusqueda;
    }

    public RichInputDate getFecFinInputDateBusqueda() {
        return fecFinInputDateBusqueda;
    }

    public void setEstadoSelectOneChoiceBusqueda(RichSelectOneChoice estadoSelectOneChoiceBusqueda) {
        this.estadoSelectOneChoiceBusqueda = estadoSelectOneChoiceBusqueda;
    }

    public RichSelectOneChoice getEstadoSelectOneChoiceBusqueda() {
        return estadoSelectOneChoiceBusqueda;
    }

    public void setFormTransformaciones(RichForm formTransformaciones) {
        this.formTransformaciones = formTransformaciones;
    }

    public RichForm getFormTransformaciones() {
        return formTransformaciones;
    }

    public void setTableOrdenesResultado(RichTable tableOrdenesResultado) {
        this.tableOrdenesResultado = tableOrdenesResultado;
    }

    public RichTable getTableOrdenesResultado() {
        return tableOrdenesResultado;
    }

    public void setPopOrdenSelec(RichPopup popOrdenSelec) {
        this.popOrdenSelec = popOrdenSelec;
    }

    public RichPopup getPopOrdenSelec() {
        return popOrdenSelec;
    }

    public void setTpOrd(RichTable tpOrd) {
        this.tpOrd = tpOrd;
    }

    public RichTable getTpOrd() {
        return tpOrd;
    }

    public void setPopBusF(RichPopup popBusF) {
        this.popBusF = popBusF;
    }

    public RichPopup getPopBusF() {
        return popBusF;
    }

    public void setTform(RichTable tform) {
        this.tform = tform;
    }

    public RichTable getTform() {
        return tform;
    }

    public void setPopDetalle(RichPopup popDetalle) {
        this.popDetalle = popDetalle;
    }

    public RichPopup getPopDetalle() {
        return popDetalle;
    }

    public void setTdetalle(RichTable tdetalle) {
        this.tdetalle = tdetalle;
    }

    public RichTable getTdetalle() {
        return tdetalle;
    }


    public void setPopInsumo(RichPopup popInsumo) {
        this.popInsumo = popInsumo;
    }

    public RichPopup getPopInsumo() {
        return popInsumo;
    }

    public void setTtipoIns(RichTable ttipoIns) {
        this.ttipoIns = ttipoIns;
    }

    public RichTable getTtipoIns() {
        return ttipoIns;
    }

    public void setReferencia(RichInputText referencia) {
        this.referencia = referencia;
    }

    public RichInputText getReferencia() {
        return referencia;
    }

    public void setPopInsumoVerdadero(RichPopup popInsumoVerdadero) {
        this.popInsumoVerdadero = popInsumoVerdadero;
    }

    public RichPopup getPopInsumoVerdadero() {
        return popInsumoVerdadero;
    }

    public void setTinsV(RichTable tinsV) {
        this.tinsV = tinsV;
    }

    public RichTable getTinsV() {
        return tinsV;
    }

    public void setSelBool1(RichSelectBooleanCheckbox selBool1) {
        this.selBool1 = selBool1;
    }

    public RichSelectBooleanCheckbox getSelBool1() {
        return selBool1;
    }

    public void setPopAlmacen(RichPopup popAlmacen) {
        this.popAlmacen = popAlmacen;
    }

    public RichPopup getPopAlmacen() {
        return popAlmacen;
    }

    public void setSooAlm(RichSelectOneChoice sooAlm) {
        this.sooAlm = sooAlm;
    }

    public RichSelectOneChoice getSooAlm() {
        return sooAlm;
    }
}
